package com.hmall.item.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmall.common.dto.PageDTO;
import com.hmall.item.mapper.ItemMapper;
import com.hmall.item.pojo.Item;
import com.hmall.item.pojo.RequestParams;
import com.hmall.item.service.IItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Service
public class ItemService extends ServiceImpl<ItemMapper, Item> implements IItemService {
    @Autowired
    private ItemMapper itemMapper;
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    public PageDTO<Item> findByPage(Long page, Long size) {
        // 创建 MyBatis-Plus 的分页对象
        Page<Item> itemPage = new Page<>(page, size);

        // 使用 MyBatis-Plus 提供的分页查询方法
        IPage<Item> result = itemMapper.selectPage(itemPage, null);  // 第二个参数可以是查询条件

        // 将查询结果封装到 PageDTO 对象中
        PageDTO<Item> pageDTO = new PageDTO<>();
        pageDTO.setTotal(result.getTotal());
        pageDTO.setList(result.getRecords());

        return pageDTO;
    }

    @Override
    public Item findById(Integer id) {
        Item item = itemMapper.selectById(id);
        return item;
    }

    @Override
    public void saveItem(Item item) {
        itemMapper.insert(item);
    }

    @Override
    public void updateItemStatus(Integer id, Integer status) {
        Item item = itemMapper.selectById(id);
        item.setStatus(status);
        itemMapper.updateById(item);
    }

    @Override
    public void updataItem(Item item) {

        itemMapper.updateById(item);
    }

    @Override
    public void deleteItem(Integer id) {
        itemMapper.deleteById(id);
    }

    @Override
    public Map<String, List<String>> getFilterOptions(RequestParams requestParams) {
        // 构建查询条件
        QueryWrapper<Item> queryWrapper = new QueryWrapper<>();

        // 动态设置查询条件
        if (requestParams.getCategory() != null) {
            queryWrapper.eq("category", requestParams.getCategory());
        }
        if (requestParams.getBrand() != null) {
            queryWrapper.eq("brand", requestParams.getBrand());
        }
        if (requestParams.getMinPrice() != null) {
            queryWrapper.ge("price", requestParams.getMinPrice());
        }
        if (requestParams.getMaxPrice() != null) {
            queryWrapper.le("price", requestParams.getMaxPrice());
        }

        // 获取去重后的类别列表
        List<Item> items = itemMapper.selectList(queryWrapper);

        // 去重获取类别和品牌
        List<String> categories = items.stream()
                .map(Item::getCategory)  // 提取每个商品的类别
                .distinct()              // 去重
                .collect(Collectors.toList());  // 收集为列表

        List<String> brands = items.stream()
                .map(Item::getBrand)    // 提取每个商品的品牌
                .distinct()             // 去重
                .collect(Collectors.toList());  // 收集为列表

        // 将结果封装成一个 Map 返回
        Map<String, List<String>> filters = new HashMap<>();
        filters.put("category", categories);
        filters.put("brand", brands);

        return filters;
    }

    @Override
    public PageDTO<Item> searchItems(RequestParams requestParams) {
        try {
            // 创建分页对象
            Page<Item> itemPage = new Page<>(requestParams.getPage(), requestParams.getSize());

            // 如果没有搜索关键字，类别，品牌和价格范围，返回缓存的热销商品Top20
            if ((requestParams.getKey() == null || requestParams.getKey().isEmpty()) &&
                    (requestParams.getCategory() == null || requestParams.getCategory().isEmpty()) &&
                    (requestParams.getBrand() == null || requestParams.getBrand().isEmpty()) &&
                    (requestParams.getMinPrice() == null || "".equals(requestParams.getMinPrice())) &&
                    (requestParams.getMaxPrice() == null || "".equals(requestParams.getMaxPrice()))) {

                // 从 Redis 获取热销商品 ID 集合
                List<String> hotSaleItemIds = redisTemplate.opsForList().range("HOT_SALE_ITEMS", 0, 19);

                if (hotSaleItemIds != null && !hotSaleItemIds.isEmpty()) {
                    // 根据这些 ID 从数据库中查询出对应的 Item 对象
                    List<Item> hotSaleItems = itemMapper.selectBatchIds(hotSaleItemIds.stream()
                            .map(Long::valueOf)
                            .collect(Collectors.toList()));

                    // 创建分页结果
                    PageDTO<Item> pageDTO = new PageDTO<>();
                    pageDTO.setTotal((long) hotSaleItems.size());
                    pageDTO.setList(hotSaleItems);
                    return pageDTO;
                }
            }

            // 构建查询条件
            QueryWrapper<Item> queryWrapper = new QueryWrapper<>();

            // 根据关键字匹配商品名称或描述
            if (requestParams.getKey() != null && !requestParams.getKey().isEmpty()) {
                queryWrapper.like("name", requestParams.getKey());
            }

            // 根据类别筛选
            if (requestParams.getCategory() != null) {
                queryWrapper.eq("category", requestParams.getCategory());
            }

            // 根据品牌筛选
            if (requestParams.getBrand() != null) {
                queryWrapper.eq("brand", requestParams.getBrand());
            }

            // 根据价格范围筛选
            if (requestParams.getMinPrice() != null) {
                queryWrapper.ge("price", requestParams.getMinPrice()*100);
            }
            if (requestParams.getMaxPrice() != null) {
                queryWrapper.le("price", requestParams.getMaxPrice()*100);
            }

            // 排序
            if (requestParams.getSortBy() != null) {
                // 校验排序字段是否合法（可以根据表的实际字段来限制）
                List<String> validSortFields = Arrays.asList("name", "price", "stock", "sold"); // 这里是合法字段列表，根据实际情况修改
                String sortBy = requestParams.getSortBy();

                if (validSortFields.contains(sortBy)) {
                    // 如果合法，使用传入的排序字段
                    queryWrapper.orderBy(true, true, sortBy); // 默认升序
                } else {
                    // 如果不合法，使用默认的排序字段
                    queryWrapper.orderBy(true, true, "name"); // 默认按 name 排序
                }
            }

            // 执行分页查询
            IPage<Item> result = itemMapper.selectPage(itemPage, queryWrapper);

            // 将查询结果封装到 PageDTO 对象中
            PageDTO<Item> pageDTO = new PageDTO<>();
            pageDTO.setTotal(result.getTotal());
            pageDTO.setList(result.getRecords());

            return pageDTO;
        } catch (Exception e) {
            // 记录异常日志
            log.error("Error in searchItems: ", e);
            throw new RuntimeException("Error performing item search", e);
        }
    }

    @Override
    public void deStock(Long itemId, Integer num) {
        // 获取当前商品的库存信息
        Item item = itemMapper.selectById(itemId);

        if (item == null) {
            throw new RuntimeException("商品不存在");
        }

        // 库存更新逻辑
        if (num > 0) { // 减少库存
            if (item.getStock() >= num) {
                item.setStock(item.getStock() - num);
                item.setSold(item.getSold()+num);
            } else {
                throw new RuntimeException("库存不足");
            }
        } else if (num < 0) { // 恢复库存
            item.setStock(item.getStock() - num); // 减去负数等于加库存
            item.setSold(item.getSold()+num);
        }

        // 更新库存到数据库
        itemMapper.updateById(item);
    }

    @Override
    public List<Item> selectTopSalesItems(int i) {
        // 使用 MyBatis-Plus 的 QueryWrapper 构建查询条件，按照销量降序排列
        QueryWrapper<Item> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("sold"); // 按销量降序排序
        queryWrapper.last("LIMIT " + 20); // 只查询前 limit 条数据

        // 执行查询并返回结果
        return itemMapper.selectList(queryWrapper);
    }


}